Web Crypto API: Átfogó útmutató kriptográfiai műveletekhez

A Web Crypto API egy JavaScript API, amely lehetővé teszi a fejlesztők számára, hogy kriptográfiai műveleteket végezzenek közvetlenül a böngészőben. Ez új lehetőségeket nyit meg biztonságos webalkalmazások létrehozásához anélkül, hogy érzékeny feladatokhoz szerveroldali feldolgozásra támaszkodnának. Ez a cikk átfogó áttekintést nyújt a Web Crypto API-ról, lefedve annak fő funkcióit, felhasználási eseteit és legjobb gyakorlatait.

Bevezetés a böngészőbeli kriptográfiába

Hagyományosan a kriptográfiai műveleteket elsősorban szerveroldalon kezelték a biztonsági aggályok és a kliensoldali JavaScript korlátai miatt. A Web Crypto API azonban biztonságos és szabványosított módszert biztosít a kriptográfiai feladatok közvetlen végrehajtására a böngészőben. Ez számos új funkciót tesz lehetővé, mint például a kliensoldali titkosítás, a biztonságos hitelesítés és a digitális aláírások, mindezt anélkül, hogy szükségtelenül továbbítanánk az érzékeny adatokat a szerverre.

A kliensoldali kriptográfia egyik fő előnye a szerverterhelés csökkentése. A kriptográfiai számítások böngészőre történő áthelyezésével a szerver más feladatokra összpontosíthat, javítva az általános alkalmazási teljesítményt. Ezenkívül a kliensoldali titkosítás fokozhatja a felhasználói adatvédelmet azáltal, hogy biztosítja az érzékeny adatok titkosítását, mielőtt azok elhagyják a felhasználó eszközét.

A Web Crypto API alapvető koncepciói

A Web Crypto API a következő alapvető koncepciókon alapul:

• Kriptográfiai algoritmusok: Az API különféle kriptográfiai algoritmusokat támogat, beleértve a szimmetrikus titkosítást (pl. AES), az aszimmetrikus titkosítást (pl. RSA), a kivonat-algoritmusokat (pl. SHA-256) és a digitális aláírási algoritmusokat (pl. ECDSA).
• Kulcsok: A kriptográfiai műveletekhez gyakran kulcsokra van szükség. A Web Crypto API mechanizmusokat biztosít kulcsok biztonságos generálásához, importálásához, exportálásához és tárolásához. A kulcsok lehetnek szimmetrikusak (titkosításhoz és visszafejtéshez egyaránt használatosak) vagy aszimmetrikusak (nyilvános és privát kulcsból állnak).
• SubtleCrypto interfész: A SubtleCrypto interfész a fő belépési pont a kriptográfiai funkciók eléréséhez. Módszereket kínál kivonatoláshoz, titkosításhoz, visszafejtéshez, aláíráshoz és ellenőrzéshez.
• Ígéretek (Promises): A Web Crypto API összes kriptográfiai művelete aszinkron, és ígéreteket (promises) ad vissza. Ez biztosítja, hogy a böngésző felhasználói felülete reszponzív maradjon, miközben potenciálisan időigényes kriptográfiai feladatokat végez.

Támogatott kriptográfiai algoritmusok

A Web Crypto API számos kriptográfiai algoritmust támogat. Íme néhány a leggyakrabban használtak közül:

Szimmetrikus titkosítás

• AES (Advanced Encryption Standard): Egy széles körben használt szimmetrikus titkosítási algoritmus. A Web Crypto API támogatja az AES-CBC, AES-CTR, AES-GCM és AES-KW módokat.

Aszimmetrikus titkosítás

• RSA (Rivest-Shamir-Adleman): Népszerű aszimmetrikus titkosítási algoritmus. A Web Crypto API támogatja az RSA-OAEP és RSA-PSS padding eljárásokat.
• ECDSA (Elliptic Curve Digital Signature Algorithm): Egy elliptikus görbe kriptográfián alapuló aszimmetrikus aláírási algoritmus.
• ECDH (Elliptic Curve Diffie-Hellman): Kulcsmegosztási protokoll, amely elliptikus görbe kriptográfián alapul.

Kivonat-algoritmusok

• SHA-256 (Secure Hash Algorithm 256-bit): Széles körben használt kivonat-algoritmus, amely 256 bites kivonatértéket állít elő.
• SHA-384 (Secure Hash Algorithm 384-bit): Kivonat-algoritmus, amely 384 bites kivonatértéket állít elő.
• SHA-512 (Secure Hash Algorithm 512-bit): Kivonat-algoritmus, amely 512 bites kivonatértéket állít elő.

Alapvető kriptográfiai műveletek

Nézzünk meg néhány alapvető kriptográfiai műveletet a Web Crypto API használatával, kódpéldákkal.

Kivonatolás (Hashing)

A kivonatolás (hashing) az adatok rögzített méretű karakterlánccá (kivonatértékké) alakításának folyamata. A kivonatolást az adatok integritásának ellenőrzésére, jelszavak tárolására és indexelésre használják.

            
async function hashData(data) {
 const encoder = new TextEncoder();
 const dataBuffer = encoder.encode(data);
 const hashBuffer = await crypto.subtle.digest('SHA-256', dataBuffer);
 const hashArray = Array.from(new Uint8Array(hashBuffer));
 const hashHex = hashArray
 .map((b) => b.toString(16).padStart(2, '0'))
 .join('');
 return hashHex;
}

// Példa használatra:
hashData('Hello, world!')
 .then((hash) => console.log('SHA-256 Hash:', hash))
 .catch((err) => console.error('Hashing error:', err));

            

              
                Copy
              
            
          

Szimmetrikus kulcsok generálása

A szimmetrikus kulcsokat ugyanazon kulccsal használják a titkosításhoz és visszafejtéshez. A Web Crypto API lehetővé teszi szimmetrikus kulcsok generálását a generateKey() metódussal.

            
async function generateAESKey() {
 return await crypto.subtle.generateKey(
 {
 name: 'AES-GCM',
 length: 256,
 },
 true, // extractable
 ['encrypt', 'decrypt'] // usages
 );
}

// Példa használatra:
generateAESKey()
 .then((key) => {
 console.log('AES Key generated:', key);
 // Használd a kulcsot titkosításhoz/visszafejtéshez
 })
 .catch((err) => console.error('Key generation error:', err));

            

              
                Copy
              
            
          

Adatok titkosítása

A titkosítás az adatok olvashatatlan formátummá alakításának folyamata azok bizalmasságának védelme érdekében. Íme egy példa adatok titkosítására AES-GCM segítségével:

            
async function encryptData(key, data) {
 const encoder = new TextEncoder();
 const dataBuffer = encoder.encode(data);
 const iv = crypto.getRandomValues(new Uint8Array(12)); // Initialization vector

 const encryptedData = await crypto.subtle.encrypt(
 {
 name: 'AES-GCM',
 iv: iv,
 },
 key,
 dataBuffer
 );

 // Kombináld az IV-t és a titkosított adatokat tároláshoz/átvitelhez
 const combined = new Uint8Array(iv.length + encryptedData.byteLength);
 combined.set(iv, 0);
 combined.set(new Uint8Array(encryptedData), iv.length);
 return combined;
}

// Példa használatra (feltételezve, hogy van egy AES kulcsod):
generateAESKey().then(key => {
 encryptData(key, 'Sensitive data')
 .then((encrypted) => {
 console.log('Encrypted data:', encrypted);
 })
 .catch((err) => console.error('Encryption error:', err));
});

            

              
                Copy
              
            
          

Adatok visszafejtése

A visszafejtés az a folyamat, amelynek során a titkosított adatokat visszaalakítják eredeti, olvasható formátummá. Íme egy példa adatok visszafejtésére AES-GCM-mal titkosított adatok esetén:

            
async function decryptData(key, combined) {
 const iv = combined.slice(0, 12);
 const encryptedData = combined.slice(12);

 const decryptedData = await crypto.subtle.decrypt(
 {
 name: 'AES-GCM',
 iv: iv,
 },
 key,
 encryptedData
 );

 const decoder = new TextDecoder();
 return decoder.decode(decryptedData);
}

// Példa használatra (feltételezve, hogy rendelkezel az AES kulccsal és a titkosított adatokkal):
generateAESKey().then(key => {
 encryptData(key, 'Sensitive data').then(encrypted => {
 decryptData(key, encrypted)
 .then((decrypted) => {
 console.log('Decrypted data:', decrypted);
 })
 .catch((err) => console.error('Decryption error:', err));
 });
});

            

              
                Copy
              
            
          

Aszimmetrikus kulcsok generálása

Az aszimmetrikus kulcsok nyilvános és privát kulcsból állnak. A nyilvános kulcs megosztható másokkal, míg a privát kulcsot titokban kell tartani. A Web Crypto API támogatja az aszimmetrikus kulcsok generálását a generateKey() metódussal.

            
async function generateRSAKey() {
 return await crypto.subtle.generateKey(
 {
 name: 'RSA-OAEP',
 modulusLength: 2048, // A kulcs hossza bitekben
 publicExponent: new Uint8Array([0x01, 0x00, 0x01]), // Általában 65537
 hash: 'SHA-256',
 },
 true, // extractable
 ['encrypt', 'decrypt'] // usages
 );
}

// Példa használatra:
generateRSAKey()
 .then((keyPair) => {
 console.log('RSA Public Key:', keyPair.publicKey);
 console.log('RSA Private Key:', keyPair.privateKey);
 // Használd a kulcsokat titkosításhoz/visszafejtéshez
 })
 .catch((err) => console.error('Key generation error:', err));

            

              
                Copy
              
            
          

Adatok aláírása

A digitális aláírásokat az adatok hitelességének és integritásának ellenőrzésére használják. A feladó a privát kulcsával írja alá az adatokat, a címzett pedig a feladó nyilvános kulcsával ellenőrzi az aláírást.

            
async function signData(privateKey, data) {
 const encoder = new TextEncoder();
 const dataBuffer = encoder.encode(data);

 const signature = await crypto.subtle.sign(
 {
 name: 'RSASSA-PKCS1-v1_5',
 hash: { name: 'SHA-256' },
 },
 privateKey,
 dataBuffer
 );

 return signature;
}

// Példa használatra (feltételezve, hogy rendelkezel egy RSA kulcspárral):
generateRSAKey().then(keyPair => {
 signData(keyPair.privateKey, 'Data to sign')
 .then((signature) => {
 console.log('Signature:', signature);
 })
 .catch((err) => console.error('Signing error:', err));
});

            

              
                Copy
              
            
          

Aláírások ellenőrzése

A digitális aláírás ellenőrzése megerősíti, hogy az adatokat nem manipulálták, és hogy azokat valóban az állított feladó írta alá.

            
async function verifySignature(publicKey, signature, data) {
 const encoder = new TextEncoder();
 const dataBuffer = encoder.encode(data);

 const isValid = await crypto.subtle.verify(
 {
 name: 'RSASSA-PKCS1-v1_5',
 hash: { name: 'SHA-256' },
 },
 publicKey,
 signature,
 dataBuffer
 );

 return isValid;
}

// Példa használatra (feltételezve, hogy rendelkezel az RSA kulcspárral és az aláírással):
generateRSAKey().then(keyPair => {
 signData(keyPair.privateKey, 'Data to sign').then(signature => {
 verifySignature(keyPair.publicKey, signature, 'Data to sign')
 .then((isValid) => {
 console.log('Signature is valid:', isValid);
 })
 .catch((err) => console.error('Verification error:', err));
 });
});

            

              
                Copy
              
            
          

Kulcskezelés

A megfelelő kulcskezelés elengedhetetlen bármely kriptográfiai rendszer biztonságához. A Web Crypto API mechanizmusokat biztosít a kulcsok biztonságos generálásához, importálásához, exportálásához és tárolásához. Azonban a kulcsok biztonságos tárolása a böngészőben kihívást jelenthet.

Kulcstárolási megfontolások

• IndexedDB: Az egyik lehetőség a kulcsok tárolása az IndexedDB-ben, egy böngésző alapú NoSQL adatbázisban. Az IndexedDB azonban nem kifejezetten biztonságos kulcstárolásra készült, ezért fontos további biztonsági intézkedéseket bevezetni, például a kulcsok titkosítása a tárolásuk előtt.
• LocalStorage/Cookies: Ezek általában nem ajánlottak kriptográfiai kulcsok tárolására, korlátozott biztonsági funkcióik és a cross-site scripting (XSS) támadások lehetősége miatt.
• Hardverbiztonsági modulok (HSM): Fejlettebb forgatókönyvek esetén böngészőbővítményeket vagy natív alkalmazásokat használhat az interfészhez hardverbiztonsági modulokkal (HSM) a biztonságos kulcstároláshoz és kriptográfiai műveletekhez.

Kulcs importálása és exportálása

A Web Crypto API lehetővé teszi kulcsok importálását és exportálását különféle formátumokban, mint például:

• JWK (JSON Web Key): JSON alapú formátum kriptográfiai kulcsok reprezentálására.
• PKCS#8: Szabványos formátum privát kulcsok tárolására.
• SPKI (Subject Public Key Info): Szabványos formátum nyilvános kulcsok tárolására.

A kulcsok importálása és exportálása hasznos lehet kulcsok átvitelére különböző rendszerek között vagy kulcsok biztonsági mentésére.

Kulcs becsomagolása és kicsomagolása

A kulcs becsomagolása egy másik kulccsal (a becsomagoló kulccsal) történő kulcs titkosításának folyamata. Ez használható a kulcsok védelmére tárolás vagy továbbítás során. A Web Crypto API támogatja a kulcsok becsomagolását és kicsomagolását olyan algoritmusokkal, mint az AES-KW és az RSA-OAEP.

A Web Crypto API felhasználási esetei

A Web Crypto API számos lehetőséget nyit meg a biztonságos webalkalmazások fejlesztésében. Íme néhány gyakori felhasználási eset:

• Kliensoldali titkosítás: Érzékeny adatok titkosítása a böngészőben, mielőtt a szerverre küldené. Ez megvédheti az adatokat a lehallgatástól és az illetéktelen hozzáféréstől.
• Biztonságos hitelesítés: Biztonságos hitelesítési mechanizmusok megvalósítása digitális aláírásokkal és kulcsátviteli protokollokkal.
• Adatintegritás-ellenőrzések: Kivonatolási algoritmusok használata a szerverről letöltött adatok integritásának ellenőrzésére.
• Biztonságos kommunikáció: Biztonságos kommunikációs csatornák létrehozása titkosítással és kulcsátviteli protokollokkal.
• Digitális jogkezelés (DRM): DRM rendszerek megvalósítása a szerzői jogvédelem alatt álló tartalom védelmére.
• Jelszókezelés: Biztonságos jelszó tárolási és lekérési mechanizmusok megvalósítása. A PBKDF2 használata a jelszavak kliensoldali kivonatolására, mielőtt a szerverre küldené őket.

Biztonsági megfontolások

Míg a Web Crypto API egy hatékony eszköz a biztonságos webalkalmazások létrehozásához, fontos tisztában lenni a lehetséges biztonsági kockázatokkal, és követni a legjobb gyakorlatokat:

• Cross-Site Scripting (XSS): Az XSS támadások veszélyeztethetik az alkalmazás biztonságát, és lehetővé tehetik a támadók számára az érzékeny adatok, beleértve a kriptográfiai kulcsok ellopását. Védje alkalmazását az XSS támadások ellen a felhasználói bemenet megfelelő tisztításával és tartalomvédelmi szabályzatok (CSP) használatával.
• Man-in-the-Middle (MITM) támadások: A MITM támadások képesek elfogni és módosítani a hálózati forgalmat, potenciálisan veszélyeztetve az adatok bizalmasságát és integritását. Védje alkalmazását a MITM támadások ellen HTTPS használatával és a szervertanúsítványok hitelességének ellenőrzésével.
• Oldalcsatorna-támadások (Side-Channel Attacks): Az oldalcsatorna támadások a kriptográfiai műveletek során kiszivárgó információkat, például időzítési eltéréseket vagy energiafogyasztást használnak ki a titkos kulcsok visszafejtésére. A Web Crypto API-t úgy tervezték, hogy csökkentse az oldalcsatorna támadások kockázatát, de fontos tisztában lenni ezzel a kockázattal, és a kriptográfiai implementáció legjobb gyakorlatait követni.
• Kulcskezelés: A biztonságos kulcskezelés kulcsfontosságú bármely kriptográfiai rendszer biztonságához. Védje kulcsait az illetéktelen hozzáféréstől, és gondoskodjon arról, hogy biztonságosan tárolják és kezeljék őket.
• Algoritmusválasztás: Válasszon olyan kriptográfiai algoritmusokat és kulcsméreteket, amelyek megfelelnek a biztonsági követelményeknek. Kerülje a gyenge vagy elavult algoritmusok használatát. Forduljon biztonsági szakértőkhöz, hogy meghatározza az alkalmazásához legmegfelelőbb algoritmusokat.
• Rendszeres frissítések: Tartsa böngészőjét és JavaScript könyvtárait naprakészen a legújabb biztonsági javításokkal. Ezekben az összetevőkben lévő sebezhetőségek veszélyeztethetik az alkalmazás biztonságát.

A Web Crypto API használatának legjobb gyakorlatai

Íme néhány legjobb gyakorlat a Web Crypto API használatához:

• Használjon HTTPS-t: Mindig használjon HTTPS-t az alkalmazás MITM támadások elleni védelme érdekében.
• Tisztítsa meg a felhasználói bemenetet: Tisztítsa meg megfelelően a felhasználói bemenetet az XSS támadások megelőzése érdekében.
• Használjon tartalomvédelmi szabályzatokat (CSP): Használjon CSP-ket az alkalmazás által betölthető erőforrások korlátozására, csökkentve ezzel az XSS támadások kockázatát.
• Válasszon erős algoritmusokat: Válasszon erős kriptográfiai algoritmusokat és kulcsméreteket, amelyek megfelelnek a biztonsági követelményeknek.
• Implementáljon biztonságos kulcskezelést: Implementáljon biztonságos kulcskezelési gyakorlatokat a kulcsok illetéktelen hozzáféréstől való védelme érdekében.
• Tartsa naprakészen a szoftverét: Tartsa naprakészen böngészőjét és JavaScript könyvtárait a legújabb biztonsági javításokkal.
• Tesztelje alaposan az alkalmazását: Tesztelje alaposan az alkalmazását a lehetséges biztonsági hibák azonosítása és javítása érdekében.
• Fontoljon meg egy kriptográfiai könyvtárat: Bár a Web Crypto API erőteljes, egy jól átvizsgált kriptográfiai könyvtár (például a TweetNaCl.js vagy a CryptoJS) használata további biztonságot és kényelmet nyújthat. Ezek a könyvtárak gyakran kezelik az alacsony szintű részleteket és a kivételes eseteket, csökkentve a hibák kockázatát.

Példák a Web Crypto API működés közben

Nézzünk meg néhány valós példát, ahol a Web Crypto API használható a biztonság és az adatvédelem fokozására:

Biztonságos üzenetküldő alkalmazás

Egy biztonságos üzenetküldő alkalmazás használhatja a Web Crypto API-t az üzenetek kliensoldali titkosítására, mielőtt a szerverre küldené őket. Ez biztosítja, hogy csak a szándékolt címzett olvashassa az üzeneteket, még akkor is, ha a szerver kompromittálódik. A felhasználók kulcspárokat generálhatnak, titkosíthatják az üzeneteket a címzett nyilvános kulcsával, és aláírhatják az üzeneteket saját privát kulcsukkal. A címzett ezután a privát kulcsával fejtheti vissza az üzenetet, és a nyilvános kulcsával ellenőrizheti a feladó aláírását.

Biztonságos fájltárolás

Egy biztonságos fájltároló alkalmazás használhatja a Web Crypto API-t a fájlok kliensoldali titkosítására, mielőtt feltöltené őket a szerverre. Ez megvédi a fájlokat az illetéktelen hozzáféréstől, még akkor is, ha a szerver kompromittálódik. A felhasználók titkosítási kulcsokat generálhatnának, titkosíthatnák a fájlokat ezekkel a kulcsokkal, majd biztonságosan tárolhatnák a titkosított fájlokat a kulcsokkal együtt (esetleg a kulcsok becsomagolásával a további védelem érdekében). Amikor egy felhasználó hozzáférni szeret egy fájlhoz, az alkalmazás lekérné a titkosított fájlt és a hozzá tartozó kulcsot, kliensoldalon visszafejtené a fájlt, majd megjelenítené a felhasználónak.

Haladó témák

Az alapokon túl a Web Crypto API számos fejlett funkciót kínál speciális felhasználási esetekhez:

• Kulcsderiváló függvények (KDF-ek): A KDF-eket kriptográfiai kulcsok származtatására használják jelszavakból vagy más titkos értékekből. A Web Crypto API támogatja a PBKDF2 (Password-Based Key Derivation Function 2) funkciót, amely egy széles körben használt KDF jelszó alapú kulcsderiváláshoz.
• Hitelesített titkosítás: A hitelesített titkosítási algoritmusok, mint például az AES-GCM és a ChaCha20-Poly1305, mind a bizalmasságot, mind az integritást biztosítják. Titkosítják az adatokat, és egy hitelesítési címkét is generálnak, amely felhasználható az adatok integritásának ellenőrzésére.
• Elliptikus görbe kriptográfia (ECC): Az ECC egy aszimmetrikus kriptográfia típusa, amely elliptikus görbéken alapul. A Web Crypto API támogatja az ECDSA (Elliptic Curve Digital Signature Algorithm) és az ECDH (Elliptic Curve Diffie-Hellman) funkciókat, amelyeket gyakran használnak digitális aláírásokhoz és kulcsátvitelhez.

Következtetés

A Web Crypto API egy hatékony és szabványosított módot biztosít a kriptográfiai műveletek közvetlen végrehajtására a böngészőben. Ez lehetővé teszi a fejlesztők számára, hogy biztonságos webalkalmazásokat hozzanak létre anélkül, hogy szerveroldali feldolgozásra támaszkodnának az érzékeny feladatokhoz. A Web Crypto API alapvető koncepcióinak megértésével, a legjobb gyakorlatok követésével és a lehetséges biztonsági kockázatok tudatában kihasználhatja ezt az erőteljes eszközt webalkalmazásai biztonságának és adatvédelmének fokozására. Ahogy a webalkalmazások egyre kifinomultabbá válnak és egyre több érzékeny adatot kezelnek, a Web Crypto API egyre fontosabb szerepet fog játszani a web biztonságának és adatvédelmének biztosításában.